This short tutorial presents a simple "Hello World" program for the STMicroelectronics STM8A-DISCOVERY STM8AF board (MB1036B), with an extra WaveShare RS232 board or Hobby Components HCCABL0015 USB to RS232 TTL Serial Interface Cable (any USB to TTL serial cable should do). The author used a Debian GNU/Linux system, but the tutorial should work for other Linux distributions, *BSD or other Unices.
The tools we use are
- The Small Device C Compiler (SDCC), version 3.7.0 or later to compile C programs for the STM8.
- stm8flash, to write programs onto devices.
Hardware setup
The STM8A-DISCOVERY board is connected to the host computer via a USB cable for power and to write the demo onto the board using the integrated stlink. We will be using pin 1 on the LIN jumper header for serial communication, and thus need to remove the jumper there. When using the WaveShare RS232 board, we connect its VCC to +5V on the Discovery, GND to GND, TxIN to pin 1 on the LIN jumper header. The USB connection stays on for power supply. If we use the Hobby Components HCCABL0015 instead, the USB connection should be removed after writing the demo on the board, before connecting the HCCABL0015. We connect the red wire to +5V, the black wire to GND, the white wire to pin 1 on the LIN jumper header.
Get SDCC
Depending on your operating system there might be an easy way to install SDCC 3.5.0 or newer using a package system or similar (e.g. apt-get install sdcc on Debian). While SDCC 3.4.0 should be sufficient for this tutorial, you might want to try a newer version in case you encounter any bugs. In particular, SDCC 3.4.0 has an issue with the library search path; this can be worked around by explicitly specifying the path to the standard library when linking.
SDCC binaries or a source tarball can be downloaded from its website.
Get stm8flash
The stm8flash source can be found at its GitHub location, where there is also a download link for a zip archive of the sources. To compile it, a C compiler, such as gcc, pkg-config and libusb need to be installed. Unzip the archive (e.g. using unzip stm8flash-master.zip) change into the directory stm8flash-master and type make. In case there are any errors, such as header files not found, check that pkg-config and development files for libusb are installed.
The Demo
We present a simple Demo that repeatedly outputs "Hello World!" on UART3 (since it is the only one connected to a pin header on the board). This demonstrates setting up and using the UART for serial I/O. Here is the C code:
#include <stdint.h>
#include <stdio.h>
#define PD_DDR (*(volatile uint8_t *)0x5011)
#define PD_CR1 (*(volatile uint8_t *)0x5012)
#define CLK_CKDIVR (*(volatile uint8_t *)0x50c6)
#define CLK_PCKENR1 (*(volatile uint8_t *)0x50c7)
#define USART3_SR (*(volatile uint8_t *)0x5240)
#define USART3_DR (*(volatile uint8_t *)0x5241)
#define USART3_BRR1 (*(volatile uint8_t *)0x5242)
#define USART3_BRR2 (*(volatile uint8_t *)0x5243)
#define USART3_CR2 (*(volatile uint8_t *)0x5245)
#define USART3_CR3 (*(volatile uint8_t *)0x5246)
#define USART_CR2_TEN (1 << 3)
#define USART_CR3_STOP2 (1 << 5)
#define USART_CR3_STOP1 (1 << 4)
#define USART_SR_TXE (1 << 7)
int putchar(int c)
{
while(!(USART3_SR & USART_SR_TXE));
USART3_DR = c;
return(c);
}
void main(void)
{
unsigned long i = 0;
CLK_CKDIVR = 0x00; // Set the frequency to 16 MHz
CLK_PCKENR1 = 0xFF; // Enable peripherals
PD_DDR = 0x20; // Put TX line on
PD_CR1 = 0x20;
USART3_CR2 = USART_CR2_TEN; // Allow TX and RX
USART3_CR3 &= ~(USART_CR3_STOP1 | USART_CR3_STOP2); // 1 stop bit
USART3_BRR2 = 0x03; USART3_BRR1 = 0x68; // 9600 baud
for(;;)
{
printf("Hello World!\n");
for(i = 0; i < 147456; i++); // Sleep
}
}
SDCC is a freestanding, not a hosted implementation of C, and allows main to return void.
We set up the timer to increment once per millisecond, which allows us to implement a basic clock() function. This function is used to control the blinking of the LEDs.
The demo can be compiled simply by invocing sdcc using sdcc -mstm8 --std-c99 serial.c assuming the C code is in serial.c. The option -mstm8 selects the target port (stm8). An .ihx file with a name corresponding to the source file will be generated.
Put the demo onto the board
Assuming stm8flash and serial.ihx are in the same directory, the board is attached through the integrated ST-LINK/V2 device, ./stm8flash -c stlinkv2 -p stm8af5288 -w serial.ihx will write the demo onto the board. You can see the "Hello world" via the serial interface cable, and using a terminal program configured for 9600 baud, no parity, 8 bits, 1 stop bit and no flow control.
More about stm8flash
stm8flash was written by Valentin Dudouyt. It works both with stlink (including the one integrated on the discovery boards) and stlinkv2 devices. The programmer can be selected using -c stlink or -c stlinkv2. The target device is selected using the -p option (to get a list of target devices, use the -p option with an option argument that is not an stm8 device, e.g. -p help. stm8flash will treat filenames ending in .ihx or .hex as Intel hex, and other filenames as binaries.
More about SDCC
SDCC was initially written by Sandeep Dutta for the MCS-51, and has a relatively conservative architecture (see Sandeep Dutta, "Anatomy of a Compiler", 2000). It has been extended by various contributors and more recently, incorporated some cutting-edge technologies, in particular in register allocation (see Philipp Klaus Krause, "Optimal Register Allocation in Polynomial Time", 2013). The stm8 backend was mostly written by Philipp Klaus Krause for his research into bytewise register allocation and spilling (see Philipp Klaus Krause, "Bytewise Register Allocation", 2015).
SDCC is a C compiler that aims to be compliant with the C standards.
Important compiler options for STM8 developers include:
-cto compile into object files to be linked later--std-c99for compilation in C99 mode (some C99 features, e.g. variable-length arrays are not yet supported in sdcc though)--opt-code-sizefor optimization for code size--max-allocs-per-nodeto select the optimization level. the default value is 3000. Higher values result in more optimized code, longer compiler runtime, and higher memory usage during compilation.